#include "Terrain.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>



/**
 * \fn void terrainInit(Terrain *pTer)
 * \brief Initialise le terrain de jeu
 * \param [in,out] pTer Terrain initialisé par terrainInit
 */

void terrainInit(Terrain *pTer)
{
	int x,y;

	const char terrain_defaut[30][55] = {
		"#######################################################",
		"#                                      #  SNAKE BLEU  #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #     SCORE    #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      ################",
		"#                                      #  SNAKE ROUGE #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #     SCORE    #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
		"#                                      #              #",
        "#######################################################"
    };

	pTer->dimx = 55;
	pTer->dimy = 30;

	pTer->tab = (char **)malloc(sizeof(char *)*pTer->dimy);
	for (y=0; y<pTer->dimy; y++)
		pTer->tab[y] = (char *)malloc(sizeof(char)*pTer->dimx);

	for(y=0;y<pTer->dimy;++y)
		for(x=0;x<pTer->dimx;++x)
			pTer->tab[y][x] = terrain_defaut[y][x];

}





/**
 * \fn void terrainLibere(Jeu *pJeu)
 * \brief Libère la mémoire utilisée par le terrain
 * \param [in,out] pTer Terrain dont on va libérer la mémoire
 */


void terrainLibere(Terrain *pTer)
{
	int y;

	for (y=0; y<pTer->dimy; y++)
		free(pTer->tab[y]);
	free(pTer->tab);

	pTer->dimx = 0;
	pTer->dimy = 0;
	pTer->tab = NULL;
}




/**
 * \fn int posPersoValide(const Terrain *pTer, const int x, const int y)
 * \brief Vérifie que la position dont les coordonnées sont passées en paramètre est bien dans le terrain
 * \param [in,out] pTer Terrain sur lequel on vérifie la position
 * \param [in] x Entier renseignant l'abscisse de la position à vérifier
 * \param [in] y Entier renseignant l'ordonnée de la position à vérifier
 */

int posPersoValide(const Terrain *pTer, const int x, const int y)
{
	if (x>=0 && x<pTer->dimx && y>=0 && y<pTer->dimy && pTer->tab[y][x]!='#' && pTer->tab[y][x]!='*')
		return 1;
	else
		return 0;
}



/**
 * \fn const char terrainGetXY(const Terrain *pTer, const int x, const int y)
 * \brief Récupère l'adresse d'un case du tableau dont les coordonnées sont passées en paramètre
 * \param [in,out] pTer Terrain sur lequel on va récupérer une case
 * \param [in] x Entier renseignant l'abscisse de la case à récupérer
 * \param [in] y Entier renseignant l'ordonnée de la case à récupérer
 */

const char terrainGetXY(const Terrain *pTer, const int x, const int y)
{
	assert( x>=0) ;
	assert( y>=0) ;
	assert( x<pTer->dimx ) ;
	assert( y<pTer->dimy ) ;
	return pTer->tab[y][x];
}





/**
 * \fn void terrainSetXY(const Terrain *pTer, const int x, const int y, const char val)
 * \brief Attribue une valeur à une case dont les coordonnées sont passées en paramètre
 * \param [in,out] pTer Terrain sur lequel on va récupérer une case
 * \param [in] x Entier renseignant l'abscisse de la case à modifier
 * \param [in] y Entier renseignant l'ordonnée de la case à modifier
 * \param [in] val Caractère à mettre dans la case dont les coordonnées sont passées en paramètre
 */

void terrainSetXY(const Terrain *pTer, const int x, const int y, const char val)
{
	assert( x>=0) ;
	assert( y>=0) ;
	assert( x<pTer->dimx ) ;
	assert( y<pTer->dimy ) ;
	pTer->tab[y][x] = val;
}



/**
 * \fn void getDimX(Terrain *pTer)
 * \brief retourne l'abscisse maximale du terrain
 * \param [in,out] pTer Terrain dont on va récupérer l'abscisse maximale
 */

const int getDimX(const Terrain *pTer)
{
	return pTer->dimx;
}





/**
 * \fn void getDimY(Terrain *pTer)
 * \brief retourne l'ordonnée maximale du terrain
 * \param [in,out] pTer Terrain dont on va récupérer l'ordonnée maximale
 */


const int getDimY(const Terrain *pTer)
{
	return pTer->dimy;
}

